FEXPSerialization.h

Go to the documentation of this file.

// © FEXP, FEXPEnterprise Solver, Ing. Vaclav Rek
// Library for structure of various files
// Compiler must support C++ ver.14 and later
#ifndef _CFEXPSERIALIZATION_H_
#define _CFEXPSERIALIZATION_H_
#include "FEXPCommon.h"

// typedef for serialized FE data
using t_SerializedData = std::vector<std::string>;
struct ICFEXPSerialize
{
  static const std::string NODE_KEY;
  static const std::string ELEM_KEY;
  static const size_t ITEM_ID_INDEX;
  // pure virtual function for NETWORK serialization/deserialization
  virtual Ptr<t_SerializedData> NetSerialize  ()                           = 0;
  virtual void                  NetDeserialize(Ptr<t_SerializedData> data) = 0;
};

// structure of model input file
#define INP_FILE_STRUCT_BLCS NmspcFileModelData::INP_FILE_BLOCK_SRUCT
#define INP_FILE_STRUCT_TABS NmspcFileModelData::INP_FILE_TABS

namespace NmspcFileModelData
{
  enum EFileBlocks { eBl1 = 0, eBl2, eBl3, eBl4, eBl5, eBl6, eBlCount };
  const std::string INP_FILE_BLOCK_SRUCT[EFileBlocks::eBlCount] =
  {
    "CALCULATION.dynamic"   ,
    "CALCULATION.material"  ,
    "CALCULATION.constrains",
    "CALCULATION.loads"     ,
    "GEOMETRY.nodes"        ,
    "GEOMETRY.elements"
  };


  enum EFileTab { eTD1 = 0, eTM1, eTCSTR_V, eTCSTR_A, eLOAD_F, eLOAD_A, eTND1, eTEL1, eTCount };
  const std::string INP_FILE_TABS[EFileTab::eTCount] =
  {
    "TAB_D1"    ,
    "TAB_M1"    ,
    "TAB_CSTR_V",
    "TAB_CSTR_A",
    "TAB_LOAD_F",
    "TAB_LOAD_A",
    "TAB_ND1"   ,
    "TAB_EL1"
  };

  class CFEXPDataTables
  {
  public:
    using t_TableDef = std::map<std::string, std::string>;
    using t_TableHed = std::map<std::string, t_TableDef>;
    using t_TableMap = std::map<std::string, t_TableHed>;

    static const t_TableDef & GetTable(const std::string & block_key, const std::string & tab_key) { return TABLE_MAP[block_key][tab_key]; }
  protected:
    // [no protected members] -----------------------------
  private:
    static t_TableMap TABLE_MAP;
  };

  // string key for model data for each block of file structure
#define INP_FILE_STRUCT_STR_KEY(cls) STRUCT_KEYS(INP_FILE_STRUCT_BLCS, CLS_KEY(cls))
  // input model data for each block of file structure
#define INP_BLOCK_CLS(cls, basecls) CLS_MAP_PAIR(INP_FILE_STRUCT_BLCS, cls, basecls)
  // input model data for each block of file structure
#define INP_TABLE_CLS(cls, basecls) CLS_MAP_PAIR(INP_FILE_STRUCT_TABS, cls, basecls)
  // gives table column definition
#define INP_FILE_TAB(block_key, tab_key) NmspcFileModelData::CFEXPDataTables::GetTable((block_key), INP_FILE_STRUCT_TABS[(tab_key)])
}

// structure of solver input file
#define SOLVER_CONFIG_FILE_STRUCT_BLCS NmspcConfigFileSolverData::SOLVER_CONFIG_INP_FILE_BLOCK_SRUCT
#define SOLVER_CONFIG_FILE_STRUCT_TABS NmspcConfigFileSolverData::SOLVER_CONFIG_INP_FILE_TAB

namespace NmspcConfigFileSolverData
{
  enum EFileBlocks { eBl1 = 0, eBl2, eBl3, eBlCount };
  const std::string SOLVER_CONFIG_INP_FILE_BLOCK_SRUCT[EFileBlocks::eBlCount] =
  {
    "SERVER.init",
    "SOLVER.input_files"            ,
    "SOLVER.calc_behaviour"
  };


  enum EFileTab { eSTIP = 0, eSTFLS, eSTFLS_DFLT, eTAB_CALC, eSTCount };
  const std::string SOLVER_CONFIG_INP_FILE_TAB[EFileTab::eSTCount] =
  {
    "TAB_IPS"     ,
    "TAB_FLS"     ,
    "TAB_FLS_DFLT",
    "TAB_CALC"
  };

  class CFEXPDataTables
  {
  public:
    using t_TableDef = std::map<std::string, std::string>;
    using t_TableHed = std::map<std::string, t_TableDef>;
    using t_TableMap = std::map<std::string, t_TableHed>;

    static const t_TableDef & GetTable(const std::string & block_key, const std::string & tab_key) { return TABLE_MAP[block_key][tab_key]; }
  protected:
    // [no protected members] -----------------------------
  private:
    static t_TableMap TABLE_MAP;
  };

  // string key for data for each block of file structure
#define SERVER_INP_FILE_STRUCT_STR_KEY(cls) STRUCT_KEYS(SOLVER_CONFIG_FILE_STRUCT_BLCS, CLS_KEY(cls))
  // input data for each block of file structure
#define SERVER_INP_BLOCK_CLS(cls, basecls) CLS_MAP_PAIR(SOLVER_CONFIG_FILE_STRUCT_BLCS, cls, basecls)
  // input data for each block of file structure
#define SERVER_INP_TABLE_CLS(cls, basecls) CLS_MAP_PAIR(SOLVER_CONFIG_FILE_STRUCT_TABS, cls, basecls)
  // gives table column definition
#define SERVER_INP_FILE_TAB(block_key, tab_key) NmspcConfigFileSolverData::CFEXPDataTables::GetTable((block_key), SOLVER_CONFIG_FILE_STRUCT_TABS[(tab_key)])
}

// structure of output file
#define RESULT_FILE_STRUCT_BLCS NmspcFileResData::RESULT_FILE_BLOCK_SRUCT
#define RESULT_FILE_STRUCT_TABS NmspcFileResData::RESULT_FILE_TAB

namespace NmspcFileResData
{
  enum EFileBlocks { eBl1 = 0, eBlCount };
  const std::string RESULT_FILE_BLOCK_SRUCT[EFileBlocks::eBlCount] =
  {
    "RESULTS"
  };


  enum EFileTab { eRTNDS = 0, eRTFERIAG, eRTCount };
  const std::string RESULT_FILE_TAB[EFileTab::eRTCount] =
  {
    "RESULTS.TAB_NDS"    ,
    "RESULTS.TAB_FETRIAG"
  };

  class CFEXPDataTables
  {
  public:
    using t_TableDef = std::map<std::string, std::string>;
    using t_TableHed = std::map<std::string, t_TableDef>;
    using t_TableMap = std::map<std::string, t_TableHed>;

    static const t_TableDef & GetTable(const std::string & block_key, const std::string & tab_key) { return TABLE_MAP[block_key][tab_key]; }
  protected:
    // [no protected members] -----------------------------
  private:
    static t_TableMap TABLE_MAP;
  };

  // string key for data for each block structure
#define RESULT_FILE_STRUCT_STR_KEY(cls) STRUCT_KEYS(RESULT_FILE_STRUCT_BLCS, CLS_KEY(cls))
  // input data for each block structure
#define RESULT_BLOCK_CLS(cls, basecls) CLS_MAP_PAIR(RESULT_FILE_STRUCT_BLCS, cls, basecls)
  // input data for each block structure
#define RESULT_TABLE_CLS(cls, basecls) CLS_MAP_PAIR(RESULT_FILE_STRUCT_TABS, cls, basecls)
  // gives table column definition
#define RESULT_FILE_TAB(block_key, tab_key) NmspcFileResData::CFEXPDataTables::GetTable((block_key), RESULT_FILE_STRUCT_TABS[(tab_key)])
}

#endif // !_CFEXPSERIALIZATION_H_